Profissional Junior em Dados


Criado em: 16/06/2022
Última Atualização: 21/06/2022
Análise feita por 🚀 Rafael Morais de Assis
Índice
  • Importar Dataset e Libs
  • Proporção da pesquisa por nível e por cargo
  • O que é ser Júnior
  • Diferença de visão de um júnior outros
  • Salário dos cargos de dados júniors
  • Diferença de visão de um júnior outros
  • Atividades de cada cargo
    • Ciência de dados
    • Engenharia de dados
    • Analista de dados

Import Libs¶

In [1]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import random

import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

import warnings
warnings.filterwarnings("ignore")

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# Configs
pd.options.display.float_format = '{:,.2f}'.format
sns.set(style="whitegrid")
sns.set_palette("Set3") 
plt.style.use('seaborn')
seed = 42
np.random.seed(seed)
random.seed(seed)

Snippets¶

In [2]:
############### MOD ##################
def pie_plot_one_feat(df, col, title, replaces={}, break_line=False, break_point=10, color_dict=None):
    df_col = df[col]
    df_col = df_col.replace(replaces)
    df_aux = df_col.value_counts().reset_index().rename(
        columns={'index': 'Valor', col: 'Quantidade'})
    
    if(break_line):
        df_aux['Valor'] = df_aux['Valor'].apply(
            lambda x:  x if len(x.split(' ')) < break_point else insert_break_line(x) )
        
    if(color_dict):
        df_aux['color'] = df_aux['Valor'].map(color_dict)
        
    fig = px.pie(
        df_aux, values='Quantidade', names='Valor', title=title,
        color_discrete_sequence=df_aux['color'] if color_dict else px.colors.qualitative.Pastel,
    )
    fig.update_traces(textposition='inside', textinfo='percent+label')
    fig.show()
In [3]:
def get_percentage_complex(df1, df_origin, col_target):
    """
    Retorna a porcentage de um valor sobre o sum no dataframe original.
    Eh necessario fazer manulamente pois se não tiver todas as combinaçoes de cat feats
    ao fazer da forma automatica da erro. Entao, eh necessario para haver
    AS COMBINAÇÇOES CAT_FEAT CUJA CONTAGEM SEJA ZERO 
    """
    array = []
    df_sum = df_origin[col_target].value_counts().reset_index()
    df_sum.columns = [col_target, 'sum']
    for index, row in df1.iterrows():
        if(row['count'] != 0):
            v = 100 * (row['count'] / df_sum[ df_sum[col_target] == row[col_target]]['sum'].iloc[0])
        else:
            v = 0
        array.append(v)
    return array

def plotly_cat_to_cat(df, catx, cat2, title='', orderby_func=None):
    """
    Amabas devem ser cat feats
    orderby_func = muitas vezes a cat_feat eh ordenavel, use essa campos para designar a funcao
    TEM QUE VERIFICAR QUANDO NAO TEM TODAS AS CATEGORIAS, AI DA ERRO
    """
    cols = [catx, cat2]
    # Faz todas as combinações dos valores unicos de cada coluna
    # por conta disos, se hovuer nao houver a ocorrencia de uma dessa combinaçoes
    # a sua contagem de porcentagem tem que ser feita  de forma analogica 
    # na funcao 'get_percentage_complex'
    df_temp = df.groupby(cols).size().to_frame('count').reindex(
        pd.MultiIndex.from_product([df[catx].unique(), df[cat2].unique()]), fill_value = 0)
    df_temp = df_temp.reset_index().dropna()
    df_temp.columns = cols + ['count']

    df_temp['percentage'] = get_percentage_complex(df_temp, df, catx)
    df_temp['total'] = df_temp['percentage']
    df_temp.columns = cols + ['Counts', 'Percentage', 'Total']

    fig = px.bar(df_temp, x=catx, y=['Total'], color=cat2,
       category_orders=orderby_func, hover_data=['Counts'],
       text=df_temp['Percentage'].apply(lambda x: '{0:1.2f}%'.format(x)),
       title=title)
    fig.show()
In [4]:
def plotly_heatmap_cat_feats(
    df, catx, caty, title='', color_scale=None, yaxis_titulo=None,
    xaxis_titulo=None, largura=700, altura=450, pct_axis=None,
    order_list_x_axis=None, order_list_y_axis=None,
    df_original_cuz_is_filtered=None
):
        """
            Método que constrói um gráfico/tabela em mapa de calor 
            Parâmetros:
            ----------
            z: valores para z (eixo z = valor = cor)
            x: valores para x (eixo x = cat values)
            y: valores para y (eixo y = cat values)
            color_scale: uma lista com escala de cores para degrade
            title: título do gráfico
            yaxis_titulo: titulo para ficar ao lado do eixo y
            xaxis_titulo: titulo para ficar ao lado do eixo x
            largura: largura do gráfico
            altura: altura do gráfico
            order_list_x_axis e order_list_y_axis: Ordem para os eixos categoricos
            pct_axis: (x||y) converte em porcentagem olhando as linhas (x) ou coluna (y)
            df_original_cuz_is_filtered: Se fizer um df.query é capaz de perder combinaçôes de x e y
                Mandndo o df original, é possível recuperar e setar como 0
        """
        # Pre processing
        dft = df[ [catx, caty] ]
        dft = dft.groupby([catx,caty]).size().reset_index()
        
        dft.columns = ['catx', 'caty', 'values']
        dft = pd.pivot_table(
            dft, values='values', index='caty',
            columns='catx', aggfunc=np.sum, fill_value=0)
        
        # df_original_cuz_is_filtered (como 'plotly_heatmap_cat_feats_3')
        # Caso 'df' ser originário de uma filtragem (exemplo df.query('cargo == "Analista de BI"'))
        # Nesse formato eh melhor, pois fazer qualquer  filtragem
        # O QUE FAZ: a filtragem pode retirar combinaçoes dos eixos x e y, e por isso
        # o codigo a seguir insere essa combinaçôes faltante como 0
        if(df_original_cuz_is_filtered is not None):
            df_original = df_original_cuz_is_filtered
            for col in df_original[catx].unique().tolist():
                if(col not in dft.columns.tolist()):
                    # add zero column
                    dft[col] = 0
            for indx in df_original[caty].unique().tolist() :
                if(indx not in dft.index.tolist()):
                    dft.loc[indx] = 0    
        
        if(order_list_x_axis):
            dft = dft[order_list_x_axis]
            
        if(order_list_y_axis):
            dft = dft.reindex(order_list_y_axis)
        
        is_porcentage = not pct_axis is None
        
        # calculate percentage in x-axis
        if(pct_axis == 'x'):
            for col in dft.columns:
                sum_values = dft[col].sum()
                dft[col] = round(100*(dft[col] / sum_values), 1)

        # calculate percentage in y-axis
        if(pct_axis == 'y'):
            for index in dft.index:
                sum_vals = dft.loc[index].sum()
                dft.loc[index] = round(100 * (dft.loc[index] / sum_vals), 2)
            
        fig = go.Figure()
        global df_out
        df_out = dft

        fig.add_trace(go.Heatmap(
            z = dft,
            x = dft.columns.tolist(),
            y = dft.index.tolist(),
            # texto para ser apresentado se for porcentagem, converter para porcentagem
            text = dft.apply(lambda col: col.round(2).astype(str)+"%") if is_porcentage else dft, 
            texttemplate = "%{text}",
            ygap = 1, # adição de uma linha em volta dos quadrados
            xgap = 1, # adição de uma linha em volta dos quadrados
            # degrade para se realizar de acordo com os valores
            colorscale = color_scale if color_scale else px.colors.sequential.Greys, 
            showscale = False, # remover a imagem de escala ao lado do gráfico
            hovertemplate= "%{x}<br>%{y}<br>%{text}<extra></extra>"
        ))

        fig.update_layout(
            title= title,
            # xaxis_tickangle = 0, # deixar as labels (ticks) do eixo x horizontalmente
            width = largura if not is_porcentage else largura + 200,
            height = altura if not is_porcentage else altura + 100,
            yaxis_title_text = yaxis_titulo if yaxis_titulo else caty, 
            xaxis_title_text = xaxis_titulo if xaxis_titulo else catx,
            xaxis_title_font_color='grey',# cor da fonte do título eixo X
            yaxis_title_font_color='grey',# cor da fonte do título eixo y
            # yaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo y
            # xaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo x
            xaxis_color='grey',# cor das labels (ticks) do eixo X
            yaxis_color='grey' # cor das labels (ticks) do eixo y
        )
        fig.show()
In [5]:
############### MOD ##################
def plotly_heatmap_cat_feats_3(
    df, catx, caty, cat3, value_cat_3, title, color_scale=None, yaxis_titulo=None,
    xaxis_titulo=None, largura = 700, altura= 450, pct=False,
    order_list_x_axis=None):
        """
            Método que constrói um gráfico/tabela em mapa de calor 
            Parâmetros:
            ----------
            z: valores para z (eixo z = valor = cor)
            x: valores para x (eixo x = cat values)
            y: valores para y (eixo y = cat values)
            escala_cor: uma lista com escala de cores para degrade
            titulo: título do gráfico
            yaxis_titulo: titulo para ficar ao lado do eixo y
            xaxis_titulo: titulo para ficar ao lado do eixo x
            largura: largura do gráfico
            altura: altura do gráfico
            pct: se os valores são porcentagem, desta forma já adiciona "%" nos textos
        """
        # insert third value
        dft = df[ df[cat3] == value_cat_3]
        
        # Pre processing
        dft = dft[ [catx, caty] ]
        dft = dft.groupby([catx,caty]).size().reset_index()
        dft.columns = ['catx', 'caty', 'values']
        dft = pd.pivot_table(
            dft, values='values', index='caty',
            columns='catx', aggfunc=np.sum, fill_value=0)
        
        # handler with third value
        # add zero col/row if necessary
        all_cols = df[catx].unique().tolist()
        all_indexs = df[caty].unique().tolist()
        for col in all_cols:
            if(col not in dft.columns.tolist()):
                # add zero column
                dft[col] = 0
        for indx in all_indexs :
            if(indx not in dft.index.tolist()):
                dft.loc[indx] = 0    
        # order x axis
        if(order_list_x_axis):
            dft = dft[order_list_x_axis]
        
        fig = go.Figure()

        fig.add_trace(go.Heatmap(
            z = dft,
            x = dft.columns.tolist(),
            y = dft.index.tolist(),
            # texto para ser apresentado se for porcentagem, converter para porcentagem
            text = dft.apply(lambda col: self.porcentagem_texto(col)) if pct else dft, 
            texttemplate = "%{text}",
            ygap = 1, # adição de uma linha em volta dos quadrados
            xgap = 1, # adição de uma linha em volta dos quadrados
            # degrade para se realizar de acordo com os valores
            colorscale = color_scale if color_scale else px.colors.sequential.Greys, 
            showscale = False, # remover a imagem de escala ao lado do gráfico
            hovertemplate= "%{x}<br>%{y}<br>%{text}<extra></extra>"
        ))

        fig.update_layout(
            title= title,
            # xaxis_tickangle = 0, # deixar as labels (ticks) do eixo x horizontalmente
            width = largura,
            height = altura,
            yaxis_title_text = yaxis_titulo if yaxis_titulo else caty, 
            xaxis_title_text = xaxis_titulo if xaxis_titulo else catx,
            xaxis_title_font_color='grey',# cor da fonte do título eixo X
            yaxis_title_font_color='grey',# cor da fonte do título eixo y
            # yaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo y
            # xaxis_tickfont_size = 12, # tamanho da fonte para labels (ticks) do eixo x
            xaxis_color='grey',# cor das labels (ticks) do eixo X
            yaxis_color='grey' # cor das labels (ticks) do eixo y
        )
        fig.show()
In [6]:
########## mod ###########
def plotly_describe_numberf_by_catf(df, number_feat, cat_feat, title='', color_dict=None):
    title = number_feat + ' by ' + cat_feat if not title else title
    # dropnan pois se houver nao conegue por as cores corretamente
    # e tambem nao muda em nada, pois so faz o box de quem NAO TEM NAN
    cols = [number_feat, cat_feat]
    adf = df[cols].dropna(axis='index', subset=cols)
    if(color_dict):
        adf['color'] = adf[cat_feat].map(color_dict)
        
    # Box Plot
    fig = px.box(
        adf, 
        x=cat_feat, 
        y=number_feat,
        color=cat_feat,
        # isso pode nao esta bem ordenado
        color_discrete_sequence=adf['color'].unique() if color_dict else None
    )
    # Configs
    fig.update_layout(
        title_text=title, 
        # title_x=0.5, # se ativado titulo fica no meio
        yaxis=dict(
            gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
        ),
        plot_bgcolor = "#fff", # fundo da cor branco
    )
    fig.show()
In [7]:
############### MOD ##################
def plotly_bar_grouped_cat_feats(
    df, catx, cat2, title='',orderby_func=None,
    percentage=False, color_dict=None, replace_dict=None, legend_dict=None):
    """
    + Parecido com 'plotly_cat_to_cat' mas com as barras separas
      Mostra a quantidade/porcentagem de valores de 'cat2' para cada 'catx'
    + Há dois modos: com e sem 'percentage'
      - com percentage é a porcentagem do valor em relaçao ao todo da legenda (cat2)
    + @color_dict = mapeia valor de 'cat2' para uma cor'#HEX'
    """
    cols = [catx, cat2]
    df_temp = df.groupby(cols).size().to_frame('count').reindex(
        pd.MultiIndex.from_product([df[catx].unique(), df[cat2].unique()]), fill_value = 0)
    df_temp = df_temp.reset_index().dropna()
    df_temp.columns = cols + ['count']

    df_temp['percentage'] = get_percentage_complex(df_temp, df, catx)
    df_temp['total'] = df_temp['percentage']
    df_temp.columns = cols + ['Counts', 'Percentage', 'Total']
    
    y_target = 'Counts'
    y_axis_title = 'Count'
    
    if(percentage):
        map_total_cat2 = df[cat2].value_counts().to_dict()
        df_temp['total_cat2'] = df_temp[cat2].map(map_total_cat2)
        df_temp['Percentage'] = 100 * (df_temp['Counts'] / df_temp['total_cat2'])
        y_target = 'Percentage'
        y_axis_title = 'Percentage'
        
    if(color_dict):
        df_temp['color'] = df_temp[cat2].map(color_dict)
        
    if(replace_dict):
        df_temp[catx].replace(replace_dict, inplace=True)

    fig = px.histogram(
        df_temp, x=catx, y=y_target, color=cat2,
        color_discrete_sequence= df_temp['color'] if color_dict else [],
        barmode='group', category_orders=orderby_func, 
        title=title,
    )
    
    fig.update_layout(
        yaxis=dict(
            title=y_axis_title, # titulo do eixo y
            gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
            ticksuffix='%' if percentage else '' # adicionar sufixo no eixo y
        ),
        xaxis_zeroline=False,
        plot_bgcolor = "#fff", # fundo da cor branco
        legend= legend_dict if legend_dict else dict(),
    )
    fig.show()
In [8]:
from math import floor

def insert_break_line(astring, index_point=5):
    """
    Usada para por <br> em textos muitos longos, que acaba atrapalhando na visualização
    """
    if(pd.isna(astring)):
        return astring
    splited = astring.split(' ')
    for i in range(floor(len(splited)/index_point)):
        splited.insert(index_point * (i+1), '<br>')
    return " ".join(splited).replace(' <br> ','<br>')

def replace_mapping_dict(adict, index_point=5):
    for key, value in adict.items():
        adict[key] = insert_break_line(value, index_point)
    return adict
In [46]:
def get_prefix_cols(prefix="('P9", df=df):
    # Retorna as colunas do DataFrame que começam com um prefixo
    return [x for x in df.columns.tolist() if x.startswith(prefix)]

def replace_map_prefix_cols_options(prefix, df=df):
    adict = {}
    for el in get_prefix_cols(prefix, df):
        if(el.count(')') >= 2):
            # evita de tirar 2 ')' quando houver mais de um
            temp = el.split("', '")[1].replace("'",'').replace(')','@@@',1)
            adict[el] = temp.replace(')','').replace('@@@',')')
        else:
            adict[el] = el.split("', '")[1].replace("'",'').replace(')','')
    return adict

def df_concat_many_options_with_statistics(df, target_col, name_cat, prefix_cols):
    # Agrupa dados de varias colunas com a contagem/porcentage/soma
    prefix_cols = get_prefix_cols(prefix_cols, df)
    df_temp = df[ [target_col] + prefix_cols ]
    list_dfs = []
    for option_col in prefix_cols:
        df_out = df_temp[[target_col ,option_col] ].groupby(
            target_col).count().reset_index().rename(
            columns={option_col: 'count'}) # df com contagem
        df_out['total_final'] = df[option_col].count()
        df_out[name_cat] = option_col
        df_sum_by_target_col = df_temp[[target_col, option_col]].groupby(target_col).sum().reset_index()
        df_out['sum'] = df_sum_by_target_col[option_col]
        df_out['percent'] = 100 * (df_out['sum'] / df_out['count'])
        list_dfs.append(df_out)
    return pd.concat(list_dfs)

df_out = None
def plot_bar_group_many_options(
    df, target_col, name_cat, prefix_cols, percentage=False, 
    color_dict=None, orderby_func=None, title='', replace_dict=None, horizontal=False, legend_dict=None, sort_bars=None
):

    df_temp = df_concat_many_options_with_statistics(df, target_col, name_cat, prefix_cols)
    
    y_target, y_axis_title = ('percent', 'Percentage') if percentage else ('sum','Count')
    
    if(replace_dict):
        df_temp[name_cat].replace(replace_dict, inplace=True)
    
    if(color_dict):
        df_temp['color'] = df_temp[target_col].map(color_dict)
        
    x, y, orientation = name_cat, y_target, 'v'

    if(horizontal):
        x, y, orientation = y_target, name_cat, 'h'
        
    global df_out
    df_out = df_temp
        
    fig = px.bar( # ou histogram, bar fica melhor
        df_temp, x=x, y=y, color=target_col, barmode='group',
        color_discrete_sequence= df_temp['color'] if color_dict else [],
        category_orders=orderby_func, orientation=orientation,
        title=title,
    )
    
    axis_dict = dict(
        title=y_axis_title, # titulo do eixo y
        gridcolor='#F5F5F5', # cor das linhas horizontais (do eixo y)
        ticksuffix='%' if percentage else '' # adicionar sufixo no eixo y
    )
    
    fig.update_layout(
        yaxis=axis_dict if orientation=='v' else {'title': ''},
        xaxis=axis_dict if orientation=='h' else {},
        xaxis_zeroline=False,
        plot_bgcolor = "#fff", # fundo da cor branco
        legend= legend_dict if legend_dict else dict(),
    )
    
    if(horizontal):
        fig.update_layout(
            height=900, # aumentar altura e largura das barras para agrupar nomes
            yaxis_categoryorder = 'total ascending', # ordenar automaticamente
            bargap=0.35 # distantancias entre as barras
        )
        
    if(sort_bars):
        fig.update_layout(xaxis_categoryorder = 'total descending')
    
    fig.show()

Import and Pre-Processing Dataset¶

In [10]:
# df = pd.read_csv('/kaggle/input/state-of-data-2021/State of Data 2021 - Dataset - Pgina1.csv', low_memory=False)
df = pd.read_csv('./State of Data 2021 - Dataset.csv', low_memory=False)
print('linhas:', df.shape[0], '| colunas:',df.shape[1])

linhas: 2645 | colunas: 356

Definir Cores e legendas¶

In [12]:
# CORES
# Defina as cores por essa paletas
# https://plotly.com/python/discrete-color/

# https://www.color-hex.com/color/e8f1f6
# busque 3 cores mais escuras (que nao apreçam pretas)
# a ultima cor clara deve ser quase branco

colors_scales = {
    'Cientista de Dados': [       
        '#f5f9fb', '#d1e4ed', '#a3c9dc',
        '#75aecb', '#4693ba', '#1979A9',
        '#146087', '#166c98', '#146087',
    ],
    'Analista de BI': [
        '#fdfcf3', '#fcf9e7', '#f8edb7',
        '#f1db6f', '#efd557', '#E9C310',
        '#d1af0e', '#ba9c0c', '#a3880b'
    ],
    'Analista de Dados': [
        '#eef6f2', '#ddede5', '#bbdbcb', 
        '#99cab2', '#77b898', '#56a77f', 
        '#4d9672', '#448565', '#3c7458',
    ],
    'Engenheiro de Dados': [
        '#fcf7f7', '#f7e6e5', '#efcdcb',
        '#e7b4b2', '#df9b98', '#d7837f',
        '#c17572', '#ac6865', '#965b58',
    ],
}

colors = {
    'Cientista de Dados': '#1979A9',
    'Analista de BI': '#E9C310',
    'Analista de Dados': '#56A77F',
    'Engenheiro de Dados': '#d7837f',
    'Júnior' : '#66c5cc',
    'Pleno' : '#b497e7',
    'Sênior': '#f89c74',
    'Gestor': '#fe88b0',
}

discrete_pallete = px.colors.qualitative.Pastel
In [13]:
# LEGENDS CONFIGS
legends = {
    'top_out': dict(
        title_text='',
        orientation="h",
        yanchor="bottom",
        y=1.02,
        xanchor="left",
        x=0
    ),
    'right_inside': dict(
        xanchor="right",
        x=1,
    ),
}

# CONSTANTS USADAS EM MANY OPTIONS
idx_title = 0

Renomear colunas¶

In [14]:
# Renomear colunas 
mapping_columns = {
    "('P2_f ', 'Cargo Atual')": 'cargo',
    "('P2_g ', 'Nivel')": 'nivel',
    "('P1_a ', 'Idade')": 'idade',
    "('P2_h ', 'Faixa salarial')": 'salario',
    "('P2_c ', 'Numero de Funcionarios')": 'numero_funcionarios',
    "('P1_h ', 'Nivel de Ensino')": 'ensino',
    "('P2_d ', 'Gestor?')": 'gestor',
    "('P2_a ', 'Qual sua situação atual de trabalho?')": 'situacao_trabalho',
    "('P2_k ', 'Você está satisfeito na sua empresa atual?')": 'satisfeito_com_emprego',
    "('P2_i ', 'Quanto tempo de experiência na área de dados você tem?')": 'experiencia_dados',
    "('P2_j ', 'Quanto tempo de experiência na área de TI/Engenharia de Software você teve antes de começar a trabalhar na área de dados?')": 'experiencia_ti',
    "('P2_n ', 'Você pretende mudar de emprego nos próximos 6 meses?')": 'pretende_mudar_emprego',
    "('P2_m ', 'Você participou de entrevistas de emprego nos últimos 6 meses?')": 'entrevista_emprego',
    # many options
    "('P2_l ', 'Qual o principal motivo da sua insatisfação com a empresa atual?')": 'insatisfacao',
    # many options
    "('P2_o ', 'Quais os principais critérios que você leva em consideração no momento de decidir onde trabalhar?')": 'considerar_onde_trabalhar',
    "('P2_q ', 'Atualmente qual a sua forma de trabalho?')": 'forma_trabalho_atual',
    "('P2_r ', 'Qual a forma de trabalho ideal para você?')": 'forma_trabalho_ideal',
    "('P2_s ', 'Caso sua empresa decida pelo modelo 100% presencial qual será sua atitude?')": 'caso_trabalhe_presencial',
    
}
df = df.rename(columns=mapping_columns)

Substituir valores¶

In [15]:
df['experiencia_dados'].replace({
    'Não tenho experiência na área de dados': 'Sem experiência'
}, inplace=True)

df['satisfeito_com_emprego'].replace({
    '1': 'Sim',
    '0': 'Não',
}, inplace=True)

df['experiencia_ti'].replace({
    'Não tive experiência na área de TI/Engenharia de Software antes de começar a trabalhar na área de dados':
    'Sem experiência em TI antes'
}, inplace=True)

mapping_faixa_salario = {
    'Menos de R$ 1.000/mês': 'Menos 1k',
    'de R$ 1.001/mês a R$ 2.000/mês': 'Entre 1K e 2K',
    'de R$ 2.001/mês a R$ 3000/mês': 'Entre 2K e 3K',
    'de R$ 3.001/mês a R$ 4.000/mês': 'Entre 3K e 4K',
    'de R$ 4.001/mês a R$ 6.000/mês': 'Entre 4K e 6K',
    'de R$ 6.001/mês a R$ 8.000/mês': 'Entre 6K e 8K',
    'de R$ 8.001/mês a R$ 12.000/mês': 'Entre 8K e 12K',
    'de R$ 12.001/mês a R$ 16.000/mês': 'Entre 12K e 16K',
    'de R$ 16.001/mês a R$ 20.000/mês': 'Entre 16K e 20K',
    'de R$ 20.001/mês a R$ 25.000/mês': 'Entre 20K e 25K',
    'de R$ 25.001/mês a R$ 30.000/mês': 'Entre 25K e 30K',
    'de R$ 30.001/mês a R$ 40.000/mês': 'Entre 30K e 40K',
    'Acima de R$ 40.001/mês': 'Acima de 40K', 
}
df['salario'] = df['salario'].map(mapping_faixa_salario)

Definir Ordem¶

In [16]:
salary_order = {"salario": list(mapping_faixa_salario.values()) }

experiencia_dados_order = {'experiencia_dados': [
    'Sem experiência', 'Menos de 1 ano', 'de 1 a 2 anos', 'de 2 a 3 anos',
    'de 4 a 5 anos','de 6 a 10 anos', 'Mais de 10 anos', 
]}

experiencia_ti_order = {'experiencia_ti': [
    'Sem experiência em TI antes', 'Menos de 1 ano', 'de 1 a 2 anos',
    'de 2 a 3 anos', 'de 4 a 5 anos', 'de 6 a 10 anos', 'Mais de 10 anos'
]}

ensino_order = {'ensino': [
    'Prefiro não informar', 'Prefiro não informar', 'Estudante de Graduação',
    'Graduação/Bacharelado', 'Pós-graduação', 'Mestrado', 'Doutorado ou Phd', 
]}

pretende_mudar_emprego_order = { 'pretende_mudar_emprego': [
    'Não estou buscando e não pretendo mudar de emprego nos próximos 6 meses',
    'Não estou buscando, mas me considero aberto a outras oportunidades',
       'Estou em busca de oportunidades dentro ou fora do Brasil',
       'Estou em busca de oportunidades, mas apenas fora do Brasil'
]}

entrevista_emprego_order = { 'entrevista_emprego': [
    'Não participei de entrevistas de empregos/processos seletivos nos últimos 6 meses',
    'Sim, fiz entrevistas mas não fui aprovado'
    'Sim, fui aprovado mas decidi não mudar de emprego',
    'Sim, fui aprovado e mudei de emprego',
]}

caso_trabalhe_presencial_order = { 'caso_trabalhe_presencial': [
    'Vou aceitar e retornar ao modelo 100% presencial.',
    'Vou procurar outra oportunidade no modelo híbrido ou remoto.',
    'Vou procurar outra oportunidade no modelo 100% remoto.'
]}

numero_funcionarios_order = { 'numero_funcionarios': [
    'de 1 a 5', 'de 6 a 10', 'de 11 a 50', 'de 51 a 100', 'de 101 a 500',
    'de 501 a 1000', 'de 1001 a 3000', 'Acima de 3000',
]}
In [17]:
df_full = df.copy() # salvar caso prceisar

Filtrar DF para as 4 principais profissões em dados¶

'Cientista de Dados', 'Analista de BI', 'Analista de Dados', 'Engenheiro de Dados'

In [18]:
# CARGO: 
# Mapeamento do formato: 'Cientista de Dados/Data Scientist' para 'Cientista de Dados'
list_cargos = df['cargo'].value_counts().index.tolist()[:4] # top 4 cargos de dados
dict_mapping_cargos = {x: x.split('/')[0] for x in list_cargos}
df['cargo'] = df['cargo'].replace(dict_mapping_cargos)
list_cargos = list(dict_mapping_cargos.values())
list_cargos
Out[18]:
['Cientista de Dados',
 'Analista de BI',
 'Analista de Dados',
 'Engenheiro de Dados']
In [19]:
# FILTRAGEM
df = df[ df['cargo'].isin(list_cargos) ]
print('linhas:', df.shape[0], '| colunas:',df.shape[1])

linhas: 1319 | colunas: 356
In [20]:
df_junior = df[ df['nivel'] == 'Júnior']
print('dataset junior: numero de linhas ::', df_junior.shape[0])

dataset junior: numero de linhas :: 442

Proporção da pesquisa por nível e por cargo¶

Proporção dos 4 cargos¶

Os 4 cargos tem proporções bem parecidas, todos els por ocupam aproximandemente 25% do dataset, sendo que há uma vnatagem a mais para cinecia de dados e uma de menos para engehiro de dados, pois tem respectivamnete 27% e 22%

In [21]:
df_temp = df["cargo"].value_counts().reset_index()
df_temp = df_temp.rename(columns={'index': 'Cargo', "cargo": "Quantidade"})
df_temp['PorcentagemNum'] = round( (df_temp['Quantidade'] / df_temp['Quantidade'].sum()) * 100.0, 2)
df_temp['Porcentagem'] = df_temp['PorcentagemNum'].apply(lambda x: str(format(x, '.2f')) + '%'  )
df_temp['color'] = df_temp['Cargo'].map(colors)

fig = px.bar(
    df_temp, x='Cargo', y='Quantidade', color='Cargo',
    text="Porcentagem", title='Proporção dos cargos',
    color_discrete_sequence=df_temp['color'],
)
fig.update_layout(
    xaxis_showgrid=False, # remoção de grid para eixo X
    xaxis_showline=False, # remoção de linhas de fundo do eixo X
    xaxis_zeroline=False,
    plot_bgcolor = "#fff", # fundo da cor branco
    yaxis_categoryorder = 'total ascending', # ordenar o gráfico na forma decrescente
    hovermode=None, # se passar o mouse em cima não acontece nada (False/None)
    showlegend=False, # remover legenda
)
fig.show()

Proporção dos 3 níveis Senioridade¶

Parecida com os cargos, como sao 3 nivesi de senoridade , ambos estao proximos de 33% sendo Junior ocupando exaemtente isso.

É mostrado que 4% estao em pleno que nao estao em Senior.

Mas é interressante que a quantidade seja a mesma

Pleno (37) > Junior (33) > Senior (29)

In [22]:
pie_plot_one_feat(df, 'nivel', 'Niveis de Senioridade', color_dict=colors)

O que é ser Júnior¶

In [23]:
plotly_bar_grouped_cat_feats(
    df, 'salario', 'nivel',
    'Porcentagem do nivel por salario',
    salary_order, 
    True,
    color_dict=colors,
    legend_dict=legends['top_out'],
)
  • JR: Aproximadamente 85% dos junior recebem até 6K com pico em 4k/6k de 28%
  • PL: Apr. 80% do pleno entre 4k a 12k com pico em 6kk/8k de 1/3
  • SN: 75% entre 6k e 16k , com pico em 8k/12k de 35%

Detalhes

  • Nivel senior é quem tem maiores chances de ter os mairoes slaaiors
  • Nivel junior é quem tem mais chance de menores salarios parando em 4k/6k
In [24]:
plotly_bar_grouped_cat_feats(
    df, 'experiencia_dados', 'nivel',
    'Porcentagem do nivel por salario',
    experiencia_dados_order, 
    True,
    color_dict=colors
)

Consideando os picos tempos então que

  • Junior: 80% até 2 anos
  • Pleno: entre 2 a 3 anos
  • Senior: Acima de 4 anos
In [25]:
plotly_bar_grouped_cat_feats(
    df, 'ensino', 'nivel',
    'Porcentagem do nivel por salario',
    ensino_order, 
    True,
    color_dict=colors
)
  • JR: Nivel de estudante ou formado em graduaçao
  • PL: Já formado podendo ter pos
  • SN: Pos-graduado em diante
In [26]:
plotly_bar_grouped_cat_feats(
    df, 'experiencia_ti', 'nivel',
    'Exp em Ti antes de entrar em dados',
    experiencia_ti_order, 
    True,
    color_dict=colors
)

O nivel de senioridade em TI acompanha o nivel de senioridade

  • Qunato mais anos trabalha em TI mais se considera JR/PL/SN

Apesar disso há o caso espcial de'sem exp em Ti'

  • quem mais temm e JR > PL > SN mas a porcentagme é bem grade
  • Qualquer pessoa pode entrar e se tornar qualquer um do niveis mesmo nao sabendo nada EM TI
In [27]:
plotly_describe_numberf_by_catf(df, 'idade', 'nivel', 'Idade por nivel', color_dict=colors)

OS box plots sao semlhantes sendo que

  • JR: 23-30; PL: 25-32; SN: 28-36

cConslusao JR > PL > SN

Quanto maior o n´veil de Senioridade, mais velho, masi exp (em dados ou em TI antes de entra em dados e MAIOR SALÁRIO

Diferença de visão de um Júnior outros¶

In [28]:
col = 'situacao_trabalho'
df[col] = df[col].apply(lambda x: insert_break_line(x, 5))

plotly_bar_grouped_cat_feats(
    df, col, 'nivel',
    'situacao_trabalho por nivel',
    experiencia_ti_order, 
    True,
    color_dict=colors
)

Quanto mais seniro mais diverso pode ser as possibilidades

  • estagiorio, obviamente só pode ser Júnior
In [29]:
df['pretende_mudar_emprego'] = df['pretende_mudar_emprego'].apply(lambda x: insert_break_line(x, 4))

plotly_bar_grouped_cat_feats(
    df, 'pretende_mudar_emprego', 'nivel',
    'pretende_mudar_emprego por nivel',
    pretende_mudar_emprego_order, 
    True,
    color_dict=colors
)

  • Em 'Estou em busca de de oportunidade dentro ou fora do brasil' o juniros esta acima de todos e o juniro esta o mais baixo em 'apenas fora do brasil'. Da pra concluir entao que o junior busca mais dentro do braasil. e quantos maior senior, mais quer buscar fora

  • 1/3 de todo o ramo está aberto

  • quanto mais senior, mesno quer mudar de emmprego

In [30]:
col = 'entrevista_emprego'
df[col] = df[col].apply(lambda x: insert_break_line(x, 5))

plotly_bar_grouped_cat_feats(
    df, col, 'nivel',
    'entrevista de emprego por nivel',
    experiencia_ti_order, 
    True,
    color_dict=colors
)
In [31]:
plotly_bar_grouped_cat_feats(
    df, 'satisfeito_com_emprego', 'nivel',
    'Satisfeito com o emprego?',
    experiencia_ti_order, 
    True,
    color_dict=colors
)
In [47]:
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options("('P2_l"), 3)

plot_bar_group_many_options(
    df, 'nivel', 'insatisfacao',
    "('P2_l", True, colors, 
    replace_dict=dict_replace,
    title='insatisfacao no trabalho')
In [48]:
dict_replace = replace_mapping_dict( replace_map_prefix_cols_options("('P2_o"), 4)

plot_bar_group_many_options(
    df, 'nivel', 'considerar_onde_trabalhar',
    "('P2_o", True, colors, 
    replace_dict=dict_replace,
    title='considerar_onde_trabalhar')
In [49]:
col = 'caso_trabalhe_presencial'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)

plotly_bar_grouped_cat_feats(
    df, col, 'nivel',
    'caso_trabalhe_presencial por nivel',
    experiencia_ti_order, 
    True,
    color_dict=colors,
    replace_dict=dict_replace,
)
In [50]:
col = 'forma_trabalho_atual'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)

plotly_bar_grouped_cat_feats(
    df, col, 'nivel',
    'forma_trabalho_atual por nivel',
    experiencia_ti_order, 
    True,
    color_dict=colors,
    replace_dict=dict_replace,
)
In [51]:
col = 'forma_trabalho_ideal'
dict_replace = replace_mapping_dict( { x: x for x in df[col].unique() }, 4)

plotly_bar_grouped_cat_feats(
    df, col, 'nivel',
    'forma_trabalho_ideal por nivel',
    experiencia_ti_order, 
    True,
    color_dict=colors,
    replace_dict=dict_replace,
)

Salário dos cargos de dados júniors¶

In [52]:
plotly_bar_grouped_cat_feats(
    df_junior, 'salario', 'cargo',
    'Porcentagem do cargo por salario para Júnior',
    salary_order, 
    True,
    color_dict=colors
)
In [53]:
plotly_bar_grouped_cat_feats(
    df, 'salario', 'cargo',
    'Porcentagem do cargo por salario considerando todos os níveis de senioridade',
    salary_order, 
    True,
    color_dict=colors
)

HeatMap: Salário x Senioridade para cada cargo¶

In [37]:
plotly_heatmap_cat_feats(
    df, 
    "salario",
    "nivel",
    title='Contagem sem considerar o cargo TODOS OS CARGOS e NIVEIS',
    order_list_x_axis=mapping_faixa_salario.values()
)
In [38]:
plotly_heatmap_cat_feats(
    df.query('cargo == "Cientista de Dados"'), 
    "salario",
    "nivel",
    title='Contagem Salario x Senioridade para Cientista de Dados',
    order_list_x_axis=mapping_faixa_salario.values(),
    color_scale = colors_scales['Cientista de Dados'],
    df_original_cuz_is_filtered=df,
)
In [39]:
plotly_heatmap_cat_feats(
    df.query('cargo == "Engenheiro de Dados"'), 
    "salario",
    "nivel",
    title='Contagem Salario x Senioridade para Cientista de Dados',
    order_list_x_axis=mapping_faixa_salario.values(),
    color_scale = colors_scales['Engenheiro de Dados'],
    df_original_cuz_is_filtered=df,
)
In [40]:
plotly_heatmap_cat_feats(
    df.query('cargo == "Analista de Dados"'), 
    "salario",
    "nivel",
    title='Contagem Salario x Senioridade para Analista de Dados',
    order_list_x_axis=mapping_faixa_salario.values(),
    color_scale = colors_scales['Analista de Dados'],
    df_original_cuz_is_filtered=df,
)
In [41]:
plotly_heatmap_cat_feats(
    df.query('cargo == "Analista de BI"'), 
    "salario",
    "nivel",
    title='Contagem Salario x Senioridade para Cientista de Dados',
    order_list_x_axis=mapping_faixa_salario.values(),
    color_scale = colors_scales['Analista de BI'],
    df_original_cuz_is_filtered=df,
)

Linguages e Ferramentas para cada cargo¶

In [54]:
col, prefix = "('P4_d ', 'Quais das linguagens listadas abaixo você utiliza no trabalho?')", "('P4_d_"
dict_replace = replace_map_prefix_cols_options(prefix)

plot_bar_group_many_options(
    df, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Linguagens usadas por cargo', sort_bars=True)
In [55]:
col, prefix = "('P4_e ', 'Entre as linguagens listadas abaixo, qual é a que você mais utiliza no trabalho?')", "('P4_e_"
dict_replace = replace_map_prefix_cols_options(prefix)

plot_bar_group_many_options(
    df, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Linguagens MAIS USADA por cargo ', sort_bars=True)
In [56]:
del_cols = """
('P4_h_e ', 'Superset')
('P4_h_f ', 'Redash')
('P4_h_g ', 'MicroStrategy')
('P4_h_h ', 'IBM Analytics/Cognos')
('P4_h_i ', 'SAP Business Objects')
('P4_h_j ', 'Oracle Business Intelligence')
('P4_h_l ', 'Salesforce/Einstein Analytics')
('P4_h_m ', 'Mode')
('P4_h_o ', 'Birst')
('P4_h_r ', 'SAS Visual Analytics')
('P4_h_t ', 'TIBCO Spotfire')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')

col, prefix = "('P4_h ', 'Quais as Ferramentas de Business Intelligence você utiliza no trabalho?')", "('P4_h_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)

plot_bar_group_many_options(
    df_temp, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Ferramenta de BI que utiliza', sort_bars=True)
In [57]:
col, prefix = "('P4_g ', 'Quais das opções de Cloud listadas abaixo você utiliza no trabalho?')", "('P4_g_"
dict_replace = replace_map_prefix_cols_options(prefix)

plot_bar_group_many_options(
    df, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Ferramenta de CLOUD que utiliza', sort_bars=True)
In [ ]:
## TOP DB
# ('P4_f_c ', 'SQL SERVER')
# ('P4_f_m ', 'PostgreSQL')
# ('P4_f_a ', 'MySQL')
# ('P4_f_b ', 'Oracle')
# ('P4_f_z ', 'Amazon Redshift')
# ('P4_f_l ', 'S3')
# ('P4_f_x ', 'Google BigQuery')
# ('P4_f_i ', 'MongoDB')
# ('P4_f_z3 ', 'Databricks')
# ('P4_f_z8 ', 'Hive')
# ('P4_f_e ', 'Amazon Aurora ou RDS')
# ('P4_f_n ', 'ElasticSearch')
# ('P4_f_z5 ', 'Presto')
# ('P4_f_q ', 'SQLite')
# ('P4_f_z2 ', 'Snowflake')
# ('P4_f_z1 ', 'Amazon Athena')
# ('P4_f_f ', 'Amazon DynamoDB')

## BOTTOM DB
# ('P4_f_d ', 'SAP')
# ('P4_f_g ', 'CoachDB')
# ('P4_f_h ', 'Cassandra')
# ('P4_f_j ', 'MariaDB')
# ('P4_f_k ', 'Datomic')
# ('P4_f_o ', 'DB2')
# ('P4_f_p ', 'Microsoft Access')
# ('P4_f_r ', 'Sybase')
# ('P4_f_s ', 'Firebase')
# ('P4_f_t ', 'Vertica')
# ('P4_f_u ', 'Redis')
# ('P4_f_v ', 'Neo4J')
# ('P4_f_y ', 'Google Firestore')
# ('P4_f_z4 ', 'HBase')
# ('P4_f_z6 ', 'Splunk')
# ('P4_f_z7 ', 'SAP HANA')
# ('P4_f_z9 ', 'Firebird')
In [58]:
del_cols = """
('P4_f_d ', 'SAP')
('P4_f_g ', 'CoachDB')
('P4_f_h ', 'Cassandra')
('P4_f_j ', 'MariaDB')
('P4_f_k ', 'Datomic')
('P4_f_o ', 'DB2')
('P4_f_p ', 'Microsoft Access')
('P4_f_r ', 'Sybase')
('P4_f_s ', 'Firebase')
('P4_f_t ', 'Vertica')
('P4_f_u ', 'Redis')
('P4_f_v ', 'Neo4J')
('P4_f_y ', 'Google Firestore')
('P4_f_z4 ', 'HBase')
('P4_f_z6 ', 'Splunk')
('P4_f_z7 ', 'SAP HANA')
('P4_f_z9 ', 'Firebird')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')

col, prefix = "('P4_f ', 'Quais dos bancos de dados/fontes de dados listados abaixo você utiliza no trabalho?')", "('P4_f_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)

plot_bar_group_many_options(
    df_temp, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Banco de Dados utilizado no trabalho - PART 1', sort_bars=True)
In [59]:
del_cols = """
('P4_f_c ', 'SQL SERVER')
('P4_f_m ', 'PostgreSQL')
('P4_f_a ', 'MySQL')
('P4_f_b ', 'Oracle')
('P4_f_z ', 'Amazon Redshift')
('P4_f_l ', 'S3')
('P4_f_x ', 'Google BigQuery')
('P4_f_i ', 'MongoDB')
('P4_f_z3 ', 'Databricks')
('P4_f_z8 ', 'Hive')
('P4_f_e ', 'Amazon Aurora ou RDS')
('P4_f_n ', 'ElasticSearch')
('P4_f_z5 ', 'Presto')
('P4_f_q ', 'SQLite')
('P4_f_z2 ', 'Snowflake')
('P4_f_z1 ', 'Amazon Athena')
('P4_f_f ', 'Amazon DynamoDB')
""".split('\n')[1:-1]
df_temp = df.drop(del_cols, axis='columns')

col, prefix = "('P4_f ', 'Quais dos bancos de dados/fontes de dados listados abaixo você utiliza no trabalho?')", "('P4_f_"
dict_replace = replace_map_prefix_cols_options(prefix, df_temp)

plot_bar_group_many_options(
    df_temp, 'cargo', col,
    prefix, True, colors, 
    replace_dict=dict_replace,
    title='Banco de Dados utilizado no trabalho - PART 2', sort_bars=True)

Atividades de cada cargo¶

Ciência de dados¶

In [69]:
df_ds = df.query(" cargo == 'Cientista de Dados'")

secao_ciencia_de_dados = {
    "('P8_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com ciência de dados?')": [
        'rotinas de ciencia de dados'  
    ],
    "('P8_b ', 'Quais as técnicas e métodos listados abaixo você costuma utilizar no trabalho?')": [
        'tecnicas e metodos de em data science'
    ],
    "('P8_c ', 'Quais dessas tecnologias fazem parte do seu dia a dia como cientista de dados?')": [
        'tecnologias usadas em ciencia de dados'
    ],
    "('P8_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo no trabalho?')": [
        'onde voce mais gasta tempo'
    ],
}
In [70]:
for pergunta, params in secao_ciencia_de_dados.items():
    col = pergunta
    prefix = col[:6] + '_'
    dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
    
        
    for el in dict_replace.values():
        print(el)

    plot_bar_group_many_options(
        df_ds, 'nivel', col,
        prefix, True, colors, 
        replace_dict=dict_replace,
        title=params[idx_title],
        horizontal=True,
        legend_dict=legends['top_out']
    )
    

Estudos Ad-hoc com o objetivo de<br>confirmar hipóteses, realizar modelos preditivos,<br>forecasts, análise de cluster para<br>resolver problemas pontuais e responder<br>perguntas das áreas de negócio.
Sou responsável pela coleta e limpeza<br>dos dados que uso para<br>análise e modelagem.
Sou responsável por entrar em contato<br>com os times de negócio<br>para definição do problema, identificar<br>a solução e apresentação de resultados.
Desenvolvo modelos de Machine Learning com<br>o objetivo de colocar em<br>produção em sistemas (produtos de dados).
Sou responsável por colocar modelos em<br>produção, criar os pipelines de<br>dados, APIs de consumo e monitoramento.
Cuido da manutenção de modelos de<br>Machine Learning já em produção,<br>atuando no monitoramento, ajustes e<br>refatoração quando necessário.
Realizo construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik, etc
Utilizo ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises estatísticas e ajustar<br>modelos.Crio e dou manutenção em<br>ETLs, DAGs e automações de pipelines de dados.
Sou responsável por criar e manter<br>a infra que meus modelos<br>e soluções rodam (clusters, servidores,<br>API, containers, etc.)

Utilizo modelos de regressão (linear, logística,<br>GLM)
Utilizo redes neurais ou modelos baseados<br>em árvore para criar modelos<br>de classificação
Desenvolvo sistemas de recomendação (RecSys)
Utilizo métodos estatísticos Bayesianos para analisar<br>dados
Utilizo técnicas de NLP (Natural Language<br>Processing) para análisar dados não-estruturados
Utilizo métodos estatísticos clássicos (Testes de<br>hipótese, análise multivariada, sobrevivência, dados<br>longitudinais, inferência estatistica) para analisar dados
Utilizo cadeias de Markov ou HMMs<br>para realizar análises de dados
Desenvolvo técnicas de Clusterização (K-means, Spectral,<br>DBScan etc)
Realizo previsões através de modelos de<br>Séries Temporais (Time Series)
Utilizo modelos de Reinforcement Learning (aprendizado<br>por reforço)
Utilizo modelos de Machine Learning para<br>detecção de fraude
Utilizo métodos de Visão Computacional
Utilizo modelos de Detecção de Churn <br>

Ferramentas de BI (PowerBI, Looker, Tableau,<br>Qlik etc)
Planilhas (Excel, Google Sheets etc)
Ambientes de desenvolvimento local (R-studio, JupyterLab,<br>Anaconda)
Ambientes de desenvolvimento na nuvem (Google<br>Colab, AWS Sagemaker, Kaggle Notebooks<br>etc)
Ferramentas de AutoML (Datarobot, H2O, Auto-Keras<br>etc)
Ferramentas de ETL (Apache Airflow, NiFi,<br>Stitch, Fivetran, Pentaho etc)
Plataformas de Machine Learning (TensorFlow, Azure<br>Machine Learning, Kubeflow etc)
Feature Store (Feast, Hopsworks, AWS Feature<br>Store, Databricks Feature Store etc)
Sistemas de controle de versão (Github,<br>DVC, Neptune, Gitlab etc)
Plataformas de Data Apps (Streamlit, Shiny,<br>Plotly Dash etc)
Ferramentas de estatística avançada como SPSS,<br>SAS, etc.
Não utilizo nenhuma dessas ferramentas no<br>meu dia a dia.

Coletando e limpando os dados que<br>uso para análise e modelagem.
Entrando em contato com os times<br>de negócio para definição do<br>problema, identificar a solução e<br>apresentação de resultados.
Desenvolvendo modelos de Machine Learning com<br>o objetivo de colocar em<br>produção em sistemas (produtos de dados).
Colocando modelos em produção, criando os<br>pipelines de dados, APIs de<br>consumo e monitoramento.
Cuidando da manutenção de modelos de<br>Machine Learning já em produção,<br>atuando no monitoramento, ajustes e<br>refatoração quando necessário.
Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik, etc.
Criando e dando manutenção em ETLs,<br>DAGs e automações de pipelines<br>de dados.
Criando e gerenciando soluções de Feature<br>Store e cultura de MLOps.
Criando e mantendo a infra que<br>meus modelos e soluções rodam<br>(clusters, servidores, API, containers, etc.)

Engenharia de dados¶

In [71]:
df_de = df.query(" cargo == 'Engenheiro de Dados'")

secao_engenharia_de_dados = {
   "('P6_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual como engenheiro de dados?')": [
        'Quais rotinas fazem parte da sua rotina como Engenheiro de dados?'  
    ],
   "('P6_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Engineer?')": [
        'Qauis tecnologias de ETL você utiliza como Engenheiro de dados'
    ],
    "('P6_g ', 'Quais as ferramentas de gestão de Qualidade de dados, Metadados e catálogo de dados você utiliza no trabalho?')": [
        'Ferramentas de Gestão de Qualidade de dados usadas em sua rotina de Engeheiro de dados'
    ],
    "('P6_h ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo?')": [
        'Em qual atividade você gasta mais tempo como cientista de dados'
    ],
}
In [72]:
for pergunta, params in secao_engenharia_de_dados.items():
    col = pergunta
    prefix = col[:6] + '_'
    dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
    
        
    for el in dict_replace.values():
        print(el)

    plot_bar_group_many_options(
        df_de, 'nivel', col,
        prefix, True, colors, 
        replace_dict=dict_replace,
        title=params[idx_title],
        horizontal=True,
        legend_dict=legends['top_out']
    )
    

Desenvolvo pipelines de dados utilizando linguagens<br>de programação como Python, Scala,<br>Java etc.
Realizo construções de ETLs em ferramentas<br>como Pentaho, Talend, Dataflow etc.
Crio consultas através da linguagem SQL<br>para exportar informações e compartilhar<br>com as áreas de negócio.
Atuo na integração de diferentes fontes<br>de dados através de plataformas<br>proprietárias como Stitch Data, Fivetran etc.
Modelo soluções de arquitetura de dados,<br>criando componentes de ingestão de<br>dados, transformação e recuperação da informação.
Desenvolvo/cuido da manutenção de repositórios de<br>dados baseados em streaming de<br>eventos como Data Lakes e<br>Data Lakehouses.
Atuo na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados como Data Warehouses,<br>Data Marts etc.
Cuido da qualidade dos dados, metadados<br>e dicionário de dados.
Nenhuma das opções listadas refletem meu<br>dia a dia.

Scripts Python
SQL & Stored Procedures
Apache Airflow
Luigi
AWS Glue
Talend
Stitch
Fivetran
Google Dataflow
Oracle Data Integrator
IBM DataStage
SAP BW ETL
SQL Server Integration Services (SSIS)
SAS Data Integration
Qlik Sense
Knime
Não utilizo ferramentas de ETL

great_expectations
dbt
AWS Deequ
Apache Griffin
Datafold
Amundsen
Monte Carlo
SODA
Big Eye
Data Band
Anomalo
Metaplane
Acceldata

Desenvolvendo pipelines de dados utilizando linguagens<br>de programação como Python, Scala,<br>Java etc.
Realizando construções de ETLs em ferramentas<br>como Pentaho, Talend, Dataflow etc.
Criando consultas através da linguagem SQL<br>para exportar informações e compartilhar<br>com as áreas de negócio.
Atuando na integração de diferentes fontes<br>de dados através de plataformas<br>proprietárias como Stitch Data, Fivetran etc.
Modelando soluções de arquitetura de dados,<br>criando componentes de ingestão de<br>dados, transformação e recuperação da informação.
Desenvolvendo/cuidando da manutenção de repositórios de<br>dados baseados em streaming de<br>eventos como Data Lakes e<br>Data Lakehouses.
Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados como Data Warehouses,<br>Data Marts etc.
Cuidando da qualidade dos dados, metadados<br>e dicionário de dados.

Analista de Dados¶

In [73]:
df_da = df.query(" cargo == 'Analista de Dados'")

secao_analise_de_dados = {
    "('P7_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com análise de dados?')": [
        'rotinas de analise de dados'  
    ],
    "('P7_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Analyst?')": [
        'ferramentas de ETL em dataAnalyse'
    ],
    "('P7_c ', 'Sua empresa utiliza alguma das ferramentas listadas para dar mais autonomia em análise de dados para as áreas de negócio?')": [
        'onde trabalha utiliza uma forma automatizada de analise'
    ],
    "('P7_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo de trabalho?')": [
        'onde voce mais gasta tempo'
    ],
}
In [74]:
for pergunta, params in secao_analise_de_dados.items():
    col = pergunta
    prefix = col[:6] + '_'
    dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 4)
    
        
    for el in dict_replace.values():
        print(el)

    plot_bar_group_many_options(
        df_da, 'nivel', col,
        prefix, True, colors, 
        replace_dict=dict_replace,
        title=params[idx_title],
        horizontal=True,
        legend_dict=legends['top_out']
    )
    

Processo e analiso dados<br>utilizando linguagens de<br>programação como Python,<br>R etc.
Realizo construções de dashboards<br>em ferramentas de<br>BI como PowerBI,<br>Tableau, Looker, Qlik etc.
Utilizo APIs para extrair<br>dados e complementar<br>minhas análises.
Realizo experimentos e estudos<br>utilizando metodologias estatísticas<br>como teste de<br>hipótese, modelos de regressão etc.
Desenvolvo/cuido da manutenção de<br>ETLs utilizando tecnologias<br>como Talend, Pentaho,<br>Airflow, Dataflow etc.
Atuo na modelagem dos<br>dados, com o<br>objetivo de criar<br>conjuntos de dados,<br>Data Warehouses, Data Marts etc.
Desenvolvo/cuido da manutenção de<br>planilhas para atender<br>as áreas de negócio.
Utilizo ferramentas avançadas de<br>estatística como SAS

Scripts Python
SQL & Stored Procedures <br>
Apache Airflow
Luigi
AWS Glue
Talend
Stitch
Fivetran
Google Dataflow
Oracle Data Integrator
IBM DataStage
SAP BW ETL
SQL Server Integration Services<br>(SSIS)
SAS Data Integration
Qlik Sense
Knime
Não utilizo ferramentas de<br>ETL

Ferramentas de AutoML como<br>H2O.ai, Data Robot,<br>BigML etc.
""Point and Click"" Analytics<br>como Alteryx, Knime,<br>Rapidminer etc.
Product metricts & Insights<br>como Mixpanel, Amplitude,<br>Adobe Analytics.
Ferramentas de análise dentro<br>de ferramentas de<br>CRM como Salesforce<br>Einstein Anaytics ou Zendesk dashboards.
Minha empresa não utiliza<br>essas ferramentas.
Não sei informar.

Processando e analisando dados<br>utilizando linguagens de<br>programação como Python,<br>R etc.
Realizando construções de dashboards<br>em ferramentas de<br>BI como PowerBI,<br>Tableau, Looker, Qlik etc.
Utilizando APIs para extrair<br>dados e complementar<br>minhas análises.
Realizando experimentos e estudos<br>utilizando metodologias estatísticas<br>como teste de<br>hipótese, modelos de regressão etc.
Desenvolvendo/cuidando da manutenção de<br>ETLs utilizando tecnologias<br>como Talend, Pentaho,<br>Airflow, Dataflow etc.
Atuando na modelagem dos<br>dados, com o<br>objetivo de criar<br>conjuntos de dados,<br>Data Warehouses, Data Marts etc.
Desenvolvendo/cuidando da manutenção de<br>planilhas do Excel<br>ou Google Sheets<br>para atender as<br>áreas de negócio.
Utilizando ferramentas avançadas de<br>estatística como SAS,<br>SPSS, Stata etc,<br>para realizar análises.

Analista de BI¶

In [75]:
df_bi = df.query(" cargo == 'Analista de BI'")

secao_analise_de_dados = {
    "('P7_a ', 'Quais das opções abaixo fazem parte da sua rotina no trabalho atual com análise de dados?')": [
        'rotinas de analise de dados'  
    ],
    "('P7_b ', 'Quais as ferramentas/tecnologias de ETL que você utiliza no trabalho como Data Analyst?')": [
        'ferramentas de ETL em dataAnalyse'
    ],
    "('P7_c ', 'Sua empresa utiliza alguma das ferramentas listadas para dar mais autonomia em análise de dados para as áreas de negócio?')": [
        'onde trabalha utiliza uma forma automatizada de analise'
    ],
    "('P7_d ', 'Em qual das opções abaixo você gasta a maior parte do seu tempo de trabalho?')": [
        'onde voce mais gasta tempo'
    ],
}
In [76]:
for pergunta, params in secao_analise_de_dados.items():
    col = pergunta
    prefix = col[:6] + '_'
    dict_replace = replace_mapping_dict( replace_map_prefix_cols_options(prefix), 6)
    
    for el in dict_replace.values():
        print(el)

    plot_bar_group_many_options(
        df_bi, 'nivel', col,
        prefix, True, colors, 
        replace_dict=dict_replace,
        title=params[idx_title],
        horizontal=True,
        legend_dict=legends['top_out']
    )
    

Processo e analiso dados utilizando linguagens<br>de programação como Python, R<br>etc.
Realizo construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc.
Utilizo APIs para extrair dados e<br>complementar minhas análises.
Realizo experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc.
Desenvolvo/cuido da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc.
Atuo na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc.
Desenvolvo/cuido da manutenção de planilhas para<br>atender as áreas de negócio.
Utilizo ferramentas avançadas de estatística como<br>SAS

Scripts Python
SQL & Stored Procedures
Apache Airflow
Luigi
AWS Glue
Talend
Stitch
Fivetran
Google Dataflow
Oracle Data Integrator
IBM DataStage
SAP BW ETL
SQL Server Integration Services (SSIS)
SAS Data Integration
Qlik Sense
Knime
Não utilizo ferramentas de ETL

Ferramentas de AutoML como H2O.ai, Data<br>Robot, BigML etc.
""Point and Click"" Analytics como Alteryx,<br>Knime, Rapidminer etc.
Product metricts & Insights como Mixpanel,<br>Amplitude, Adobe Analytics.
Ferramentas de análise dentro de ferramentas<br>de CRM como Salesforce Einstein<br>Anaytics ou Zendesk dashboards.
Minha empresa não utiliza essas ferramentas. <br>
Não sei informar.

Processando e analisando dados utilizando linguagens<br>de programação como Python, R<br>etc.
Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc.
Utilizando APIs para extrair dados e<br>complementar minhas análises.
Realizando experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc.
Desenvolvendo/cuidando da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc.
Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc.
Desenvolvendo/cuidando da manutenção de planilhas do<br>Excel ou Google Sheets para<br>atender as áreas de negócio.
Utilizando ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises.
In [68]:
for el in dict_replace.values():
    print(el)

Processando e analisando dados utilizando linguagens<br>de programação como Python, R<br>etc.
Realizando construções de dashboards em ferramentas<br>de BI como PowerBI, Tableau,<br>Looker, Qlik etc.
Utilizando APIs para extrair dados e<br>complementar minhas análises.
Realizando experimentos e estudos utilizando metodologias<br>estatísticas como teste de hipótese,<br>modelos de regressão etc.
Desenvolvendo/cuidando da manutenção de ETLs utilizando<br>tecnologias como Talend, Pentaho, Airflow,<br>Dataflow etc.
Atuando na modelagem dos dados, com<br>o objetivo de criar conjuntos<br>de dados, Data Warehouses, Data<br>Marts etc.
Desenvolvendo/cuidando da manutenção de planilhas do<br>Excel ou Google Sheets para<br>atender as áreas de negócio.
Utilizando ferramentas avançadas de estatística como<br>SAS, SPSS, Stata etc, para<br>realizar análises.
In [ ]: